﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ChiDao.Component.Utils
{
    /// <summary>
    ///     通用类型扩展方法类
    /// </summary>
    public static class ObjectExtensions
    {
        /// <summary>
        ///     把对象类型转化为指定类型，转化失败时返回该类型默认值
        /// </summary>
        /// <typeparam name="T"> 动态类型 </typeparam>
        /// <param name="value"> 要转化的源对象 </param>
        /// <returns> 转化后的指定类型的对象，转化失败返回类型的默认值 </returns>
        public static T CastTo<T>(this object value)
        {
            object result;
            Type type = typeof(T);
            try
            {
                if (type.IsEnum)
                {
                    result = Enum.Parse(type, value.ToString());
                }
                else if (type == typeof(Guid))
                {
                    result = Guid.Parse(value.ToString());
                }
                else
                {
                    result = Convert.ChangeType(value, type);
                }
            }
            catch
            {
                result = default(T);
            }

            return (T)result;
        }

        /// <summary>
        ///     把对象类型转化为指定类型，转化失败时返回指定的默认值
        /// </summary>
        /// <typeparam name="T"> 动态类型 </typeparam>
        /// <param name="value"> 要转化的源对象 </param>
        /// <param name="defaultValue"> 转化失败返回的指定默认值 </param>
        /// <returns> 转化后的指定类型对象，转化失败时返回指定的默认值 </returns>
        public static T CastTo<T>(this object value, T defaultValue)
        {
            object result;
            Type type = typeof(T);
            try
            {
                result = type.IsEnum ? Enum.Parse(type, value.ToString()) : Convert.ChangeType(value, type);
            }
            catch
            {
                result = defaultValue;
            }
            return (T)result;
        }

        /// <summary>
        /// 不同类型对象之间的赋值
        /// </summary>
        /// <typeparam name="T">各种类型</typeparam>
        /// <param name="sourceObject">来源类型对象</param>
        /// <returns></returns>
        public static T CopyTo<T>(this object sourceObject) where T : new()  //加入new()是为了T能够在方法体内初始化
        {
            T targetObject = new T();  //初始化T对象
            //T targetObject = System.Activator.CreateInstance<T>();  //若无采用new T()，可采用此方法进行初始化

            var targetProperties = targetObject.GetType().GetProperties();  //取得目标对象的属性集合
            var sourceProperties = sourceObject.GetType().GetProperties();  //取得来源对象的属性集合

            List<string> usedPropertyNames = new List<string>();  //定义已经进行赋值处理的属性名称（减少循环次数）

            //循环目标对象
            foreach (var targetProperty in targetProperties)
            {
                //循环来源对象
                foreach (var sourceProperty in sourceProperties)
                {
                    //如果前面已进行赋值处理，则跳过
                    if (usedPropertyNames.Contains(sourceProperty.Name))
                        continue;

                    //如果目标对象的属性名称/属性类型与来源对象的属性名称/属性类型匹配，则进行赋值操作
                    if (sourceProperty.Name.Equals(targetProperty.Name) && sourceProperty.PropertyType.Equals(targetProperty.PropertyType))
                    {
                        targetProperty.SetValue(targetObject, sourceProperty.GetValue(sourceObject, null), null);
                        usedPropertyNames.Add(sourceProperty.Name);  //将已进行赋值处理的加到列表
                        break;
                    }
                }
            }
            return targetObject;
        }
    }
}